home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / C / hf^k-2.dms / in.adf / MUIClass.Lha / Include / Classes / TWiMUI / Label.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-02  |  18.1 KB  |  729 lines
  1. //
  2. //  $VER: Label.h       1.2 (31 Aug 1996)
  3. //
  4. //    c 1996 Thomas Wilhelmi
  5. //
  6. //
  7. // Address : Taunusstrasse 14
  8. //           61138 Niederdorfelden
  9. //           Germany
  10. //
  11. //  E-Mail : willi@twi.rhein-main.de
  12. //
  13. //   Phone : +49 (0)6101 531060
  14. //   Fax   : +49 (0)6101 531061
  15. //
  16. //
  17. //  $HISTORY:
  18. //
  19. //  16 Jun 1996 :   1.0 : first public Release
  20. //
  21. //  31 Aug 1996 :   1.2 : Änderungen
  22. //                        - Parameter des Copy-Konstruktor als 'const'-Parameter definiert
  23. //
  24.  
  25. #ifndef CPP_TWIMUI_LABEL_H
  26. #define CPP_TWIMUI_LABEL_H
  27.  
  28. #ifndef CPP_TWIMUI_TEXT_H
  29. #include <classes/twimui/text.h>
  30. #endif
  31.  
  32. class MUILabel : public MUIText
  33.     {
  34.     public:
  35.         MUILabel(const STRPTR lab)
  36.             :   MUIText(
  37.                     MUIA_Text_Contents, lab,
  38.                     MUIA_Weight, 0,
  39.                     MUIA_InnerLeft, 0,
  40.                     MUIA_InnerRight, 0,
  41.                     MUIA_FramePhantomHoriz, TRUE,
  42.                     MUIA_Text_PreParse, MUIX_R,
  43.                     TAG_DONE)
  44.             { };
  45.         MUILabel(const MUILabel &p) : MUIText((MUIText &)p) { };
  46.         virtual ~MUILabel();
  47.         MUILabel &operator= (const MUILabel &);
  48.     };
  49.  
  50. class MUILabel1 : public MUIText
  51.     {
  52.     public:
  53.         MUILabel1(const STRPTR lab)
  54.             :   MUIText(
  55.                     MUIA_Text_Contents, lab,
  56.                     MUIA_Weight, 0,
  57.                     MUIA_InnerLeft, 0,
  58.                     MUIA_InnerRight, 0,
  59.                     MUIA_FramePhantomHoriz, TRUE,
  60.                     MUIA_Frame, MUIV_Frame_Button,
  61.                     MUIA_Text_PreParse, MUIX_R,
  62.                     TAG_DONE)
  63.             { };
  64.         MUILabel1(const MUILabel1 &p) : MUIText((MUIText &)p) { };
  65.         virtual ~MUILabel1();
  66.         MUILabel1 &operator= (const MUILabel1 &);
  67.     };
  68.  
  69. class MUILabel2 : public MUIText
  70.     {
  71.     public:
  72.         MUILabel2(const STRPTR lab)
  73.             :   MUIText(
  74.                     MUIA_Text_Contents, lab,
  75.                     MUIA_Weight, 0,
  76.                     MUIA_InnerLeft, 0,
  77.                     MUIA_InnerRight, 0,
  78.                     MUIA_FramePhantomHoriz, TRUE,
  79.                     MUIA_Frame, MUIV_Frame_String,
  80.                     MUIA_Text_PreParse, MUIX_R,
  81.                     TAG_DONE)
  82.             { };
  83.         MUILabel2(const MUILabel2 &p) : MUIText((MUIText &)p) { };
  84.         virtual ~MUILabel2();
  85.         MUILabel2 &operator= (const MUILabel2 &);
  86.     };
  87.  
  88. class MUILLabel : public MUIText
  89.     {
  90.     public:
  91.         MUILLabel(const STRPTR lab)
  92.             :   MUIText(
  93.                     MUIA_Text_Contents, lab,
  94.                     MUIA_Weight, 0,
  95.                     MUIA_InnerLeft, 0,
  96.                     MUIA_InnerRight, 0,
  97.                     MUIA_FramePhantomHoriz, TRUE,
  98.                     TAG_DONE)
  99.             { };
  100.         MUILLabel(const MUILLabel &p) : MUIText((MUIText &)p) { };
  101.         virtual ~MUILLabel();
  102.         MUILLabel &operator= (const MUILLabel &);
  103.     };
  104.  
  105. class MUILLabel1 : public MUIText
  106.     {
  107.     public:
  108.         MUILLabel1(const STRPTR lab)
  109.             :   MUIText(
  110.                     MUIA_Text_Contents, lab,
  111.                     MUIA_Weight, 0,
  112.                     MUIA_InnerLeft, 0,
  113.                     MUIA_InnerRight, 0,
  114.                     MUIA_FramePhantomHoriz, TRUE,
  115.                     MUIA_Frame, MUIV_Frame_Button,
  116.                     TAG_DONE)
  117.             { };
  118.         MUILLabel1(const MUILLabel1 &p) : MUIText((MUIText &)p) { };
  119.         virtual ~MUILLabel1();
  120.         MUILLabel1 &operator= (const MUILLabel1 &);
  121.     };
  122.  
  123. class MUILLabel2 : public MUIText
  124.     {
  125.     public:
  126.         MUILLabel2(const STRPTR lab)
  127.             :   MUIText(
  128.                     MUIA_Text_Contents, lab,
  129.                     MUIA_Weight, 0,
  130.                     MUIA_InnerLeft, 0,
  131.                     MUIA_InnerRight, 0,
  132.                     MUIA_FramePhantomHoriz, TRUE,
  133.                     MUIA_Frame, MUIV_Frame_String,
  134.                     TAG_DONE)
  135.             { };
  136.         MUILLabel2(const MUILLabel2 &p) : MUIText((MUIText &)p) { };
  137.         virtual ~MUILLabel2();
  138.         MUILLabel2 &operator= (const MUILLabel2 &);
  139.     };
  140.  
  141. class MUICLabel : public MUIText
  142.     {
  143.     public:
  144.         MUICLabel(const STRPTR lab)
  145.             :   MUIText(
  146.                     MUIA_Text_Contents, lab,
  147.                     MUIA_Weight, 0,
  148.                     MUIA_InnerLeft, 0,
  149.                     MUIA_InnerRight, 0,
  150.                     MUIA_FramePhantomHoriz, TRUE,
  151.                     MUIA_Text_PreParse, MUIX_C,
  152.                     TAG_DONE)
  153.             { };
  154.         MUICLabel(const MUICLabel &p) : MUIText((MUIText &)p) { };
  155.         virtual ~MUICLabel();
  156.         MUICLabel &operator= (const MUICLabel &);
  157.     };
  158.  
  159. class MUICLabel1 : public MUIText
  160.     {
  161.     public:
  162.         MUICLabel1(const STRPTR lab)
  163.             :   MUIText(
  164.                     MUIA_Text_Contents, lab,
  165.                     MUIA_Weight, 0,
  166.                     MUIA_InnerLeft, 0,
  167.                     MUIA_InnerRight, 0,
  168.                     MUIA_FramePhantomHoriz, TRUE,
  169.                     MUIA_Text_PreParse, MUIX_C,
  170.                     MUIA_Frame, MUIV_Frame_Button,
  171.                     TAG_DONE)
  172.             { };
  173.         MUICLabel1(const MUICLabel1 &p) : MUIText((MUIText &)p) { };
  174.         virtual ~MUICLabel1();
  175.         MUICLabel1 &operator= (const MUICLabel1 &);
  176.     };
  177.  
  178. class MUICLabel2 : public MUIText
  179.     {
  180.     public:
  181.         MUICLabel2(const STRPTR lab)
  182.             :   MUIText(
  183.                     MUIA_Text_Contents, lab,
  184.                     MUIA_Weight, 0,
  185.                     MUIA_InnerLeft, 0,
  186.                     MUIA_InnerRight, 0,
  187.                     MUIA_FramePhantomHoriz, TRUE,
  188.                     MUIA_Text_PreParse, MUIX_C,
  189.                     MUIA_Frame, MUIV_Frame_String,
  190.                     TAG_DONE)
  191.             { };
  192.         MUICLabel2(const MUICLabel2 &p) : MUIText((MUIText &)p) { };
  193.         virtual ~MUICLabel2();
  194.         MUICLabel2 &operator= (const MUICLabel2 &);
  195.     };
  196.  
  197. class MUIKeyLabel : public MUIText
  198.     {
  199.     public:
  200.         MUIKeyLabel(const STRPTR lab, const UBYTE hichar)
  201.             :   MUIText(
  202.                     MUIA_Text_Contents, lab,
  203.                     MUIA_Weight, 0,
  204.                     MUIA_InnerLeft, 0,
  205.                     MUIA_InnerRight, 0,
  206.                     MUIA_FramePhantomHoriz, TRUE,
  207.                     MUIA_Text_HiChar, hichar,
  208.                     MUIA_Text_PreParse, MUIX_R,
  209.                     TAG_DONE)
  210.             { };
  211.         MUIKeyLabel(const MUIKeyLabel &p) : MUIText((MUIText &)p) { };
  212.         virtual ~MUIKeyLabel();
  213.         MUIKeyLabel &operator= (const MUIKeyLabel &);
  214.     };
  215.  
  216. class MUIKeyLabel1 : public MUIText
  217.     {
  218.     public:
  219.         MUIKeyLabel1(const STRPTR lab, const UBYTE hichar)
  220.             :   MUIText(
  221.                     MUIA_Text_Contents, lab,
  222.                     MUIA_Weight, 0,
  223.                     MUIA_InnerLeft, 0,
  224.                     MUIA_InnerRight, 0,
  225.                     MUIA_FramePhantomHoriz, TRUE,
  226.                     MUIA_Text_HiChar, hichar,
  227.                     MUIA_Frame, MUIV_Frame_Button,
  228.                     MUIA_Text_PreParse, MUIX_R,
  229.                     TAG_DONE)
  230.             { };
  231.         MUIKeyLabel1(const MUIKeyLabel1 &p) : MUIText((MUIText &)p) { };
  232.         virtual ~MUIKeyLabel1();
  233.         MUIKeyLabel1 &operator= (const MUIKeyLabel1 &);
  234.     };
  235.  
  236. class MUIKeyLabel2 : public MUIText
  237.     {
  238.     public:
  239.         MUIKeyLabel2(const STRPTR lab, const UBYTE hichar)
  240.             :   MUIText(
  241.                     MUIA_Text_Contents, lab,
  242.                     MUIA_Weight, 0,
  243.                     MUIA_InnerLeft, 0,
  244.                     MUIA_InnerRight, 0,
  245.                     MUIA_FramePhantomHoriz, TRUE,
  246.                     MUIA_Text_HiChar, hichar,
  247.                     MUIA_Frame, MUIV_Frame_String,
  248.                     MUIA_Text_PreParse, MUIX_R,
  249.                     TAG_DONE)
  250.             { };
  251.         MUIKeyLabel2(const MUIKeyLabel2 &p) : MUIText((MUIText &)p) { };
  252.         virtual ~MUIKeyLabel2();
  253.         MUIKeyLabel2 &operator= (const MUIKeyLabel2 &);
  254.     };
  255.  
  256. class MUIKeyLLabel : public MUIText
  257.     {
  258.     public:
  259.         MUIKeyLLabel(const STRPTR lab, const UBYTE hichar)
  260.             :   MUIText(
  261.                     MUIA_Text_Contents, lab,
  262.                     MUIA_Weight, 0,
  263.                     MUIA_InnerLeft, 0,
  264.                     MUIA_InnerRight, 0,
  265.                     MUIA_FramePhantomHoriz, TRUE,
  266.                     MUIA_Text_HiChar, hichar,
  267.                     TAG_DONE)
  268.             { };
  269.         MUIKeyLLabel(const MUIKeyLLabel &p) : MUIText((MUIText &)p) { };
  270.         virtual ~MUIKeyLLabel();
  271.         MUIKeyLLabel &operator= (const MUIKeyLLabel &);
  272.     };
  273.  
  274. class MUIKeyLLabel1 : public MUIText
  275.     {
  276.     public:
  277.         MUIKeyLLabel1(const STRPTR lab, const UBYTE hichar)
  278.             :   MUIText(
  279.                     MUIA_Text_Contents, lab,
  280.                     MUIA_Weight, 0,
  281.                     MUIA_InnerLeft, 0,
  282.                     MUIA_InnerRight, 0,
  283.                     MUIA_FramePhantomHoriz, TRUE,
  284.                     MUIA_Text_HiChar, hichar,
  285.                     MUIA_Frame, MUIV_Frame_Button,
  286.                     TAG_DONE)
  287.             { };
  288.         MUIKeyLLabel1(const MUIKeyLLabel1 &p) : MUIText((MUIText &)p) { };
  289.         virtual ~MUIKeyLLabel1();
  290.         MUIKeyLLabel1 &operator= (const MUIKeyLLabel1 &);
  291.     };
  292.  
  293. class MUIKeyLLabel2 : public MUIText
  294.     {
  295.     public:
  296.         MUIKeyLLabel2(const STRPTR lab, const UBYTE hichar)
  297.             :   MUIText(
  298.                     MUIA_Text_Contents, lab,
  299.                     MUIA_Weight, 0,
  300.                     MUIA_InnerLeft, 0,
  301.                     MUIA_InnerRight, 0,
  302.                     MUIA_FramePhantomHoriz, TRUE,
  303.                     MUIA_Text_HiChar, hichar,
  304.                     MUIA_Frame, MUIV_Frame_String,
  305.                     TAG_DONE)
  306.             { };
  307.         MUIKeyLLabel2(const MUIKeyLLabel2 &p) : MUIText((MUIText &)p) { };
  308.         virtual ~MUIKeyLLabel2();
  309.         MUIKeyLLabel2 &operator= (const MUIKeyLLabel2 &);
  310.     };
  311.  
  312. class MUIKeyCLabel : public MUIText
  313.     {
  314.     public:
  315.         MUIKeyCLabel(const STRPTR lab, const UBYTE hichar)
  316.             :   MUIText(
  317.                     MUIA_Text_Contents, lab,
  318.                     MUIA_Weight, 0,
  319.                     MUIA_InnerLeft, 0,
  320.                     MUIA_InnerRight, 0,
  321.                     MUIA_FramePhantomHoriz, TRUE,
  322.                     MUIA_Text_HiChar, hichar,
  323.                     MUIA_Text_PreParse, MUIX_C,
  324.                     TAG_DONE)
  325.             { };
  326.         MUIKeyCLabel(const MUIKeyCLabel &p) : MUIText((MUIText &)p) { };
  327.         virtual ~MUIKeyCLabel();
  328.         MUIKeyCLabel &operator= (const MUIKeyCLabel &);
  329.     };
  330.  
  331. class MUIKeyCLabel1 : public MUIText
  332.     {
  333.     public:
  334.         MUIKeyCLabel1(const STRPTR lab, const UBYTE hichar)
  335.             :   MUIText(
  336.                     MUIA_Text_Contents, lab,
  337.                     MUIA_Weight, 0,
  338.                     MUIA_InnerLeft, 0,
  339.                     MUIA_InnerRight, 0,
  340.                     MUIA_FramePhantomHoriz, TRUE,
  341.                     MUIA_Text_HiChar, hichar,
  342.                     MUIA_Text_PreParse, MUIX_C,
  343.                     MUIA_Frame, MUIV_Frame_Button,
  344.                     TAG_DONE)
  345.             { };
  346.         MUIKeyCLabel1(const MUIKeyCLabel1 &p) : MUIText((MUIText &)p) { };
  347.         virtual ~MUIKeyCLabel1();
  348.         MUIKeyCLabel1 &operator= (const MUIKeyCLabel1 &);
  349.     };
  350.  
  351. class MUIKeyCLabel2 : public MUIText
  352.     {
  353.     public:
  354.         MUIKeyCLabel2(const STRPTR lab, const UBYTE hichar)
  355.             :   MUIText(
  356.                     MUIA_Text_Contents, lab,
  357.                     MUIA_Weight, 0,
  358.                     MUIA_InnerLeft, 0,
  359.                     MUIA_InnerRight, 0,
  360.                     MUIA_FramePhantomHoriz, TRUE,
  361.                     MUIA_Text_HiChar, hichar,
  362.                     MUIA_Text_PreParse, MUIX_C,
  363.                     MUIA_Frame, MUIV_Frame_String,
  364.                     TAG_DONE)
  365.             { };
  366.         MUIKeyCLabel2(const MUIKeyCLabel2 &p) : MUIText((MUIText &)p) { };
  367.         virtual ~MUIKeyCLabel2();
  368.         MUIKeyCLabel2 &operator= (const MUIKeyCLabel2 &);
  369.     };
  370.  
  371. class MUIFreeLabel : public MUIText
  372.     {
  373.     public:
  374.         MUIFreeLabel(const STRPTR lab)
  375.             :   MUIText(
  376.                     MUIA_Text_Contents, lab,
  377.                     MUIA_Weight, 0,
  378.                     MUIA_InnerLeft, 0,
  379.                     MUIA_InnerRight, 0,
  380.                     MUIA_FramePhantomHoriz, TRUE,
  381.                     MUIA_Text_SetVMax, FALSE,
  382.                     MUIA_Text_PreParse, MUIX_R,
  383.                     TAG_DONE)
  384.             { };
  385.         MUIFreeLabel(const MUIFreeLabel &p) : MUIText((MUIText &)p) { };
  386.         virtual ~MUIFreeLabel();
  387.         MUIFreeLabel &operator= (const MUIFreeLabel &);
  388.     };
  389.  
  390. class MUIFreeLabel1 : public MUIText
  391.     {
  392.     public:
  393.         MUIFreeLabel1(const STRPTR lab)
  394.             :   MUIText(
  395.                     MUIA_Text_Contents, lab,
  396.                     MUIA_Weight, 0,
  397.                     MUIA_InnerLeft, 0,
  398.                     MUIA_InnerRight, 0,
  399.                     MUIA_FramePhantomHoriz, TRUE,
  400.                     MUIA_Text_SetVMax, FALSE,
  401.                     MUIA_Frame, MUIV_Frame_Button,
  402.                     MUIA_Text_PreParse, MUIX_R,
  403.                     TAG_DONE)
  404.             { };
  405.         MUIFreeLabel1(const MUIFreeLabel1 &p) : MUIText((MUIText &)p) { };
  406.         virtual ~MUIFreeLabel1();
  407.         MUIFreeLabel1 &operator= (const MUIFreeLabel1 &);
  408.     };
  409.  
  410. class MUIFreeLabel2 : public MUIText
  411.     {
  412.     public:
  413.         MUIFreeLabel2(const STRPTR lab)
  414.             :   MUIText(
  415.                     MUIA_Text_Contents, lab,
  416.                     MUIA_Weight, 0,
  417.                     MUIA_InnerLeft, 0,
  418.                     MUIA_InnerRight, 0,
  419.                     MUIA_FramePhantomHoriz, TRUE,
  420.                     MUIA_Text_SetVMax, FALSE,
  421.                     MUIA_Frame, MUIV_Frame_String,
  422.                     MUIA_Text_PreParse, MUIX_R,
  423.                     TAG_DONE)
  424.             { };
  425.         MUIFreeLabel2(const MUIFreeLabel2 &p) : MUIText((MUIText &)p) { };
  426.         virtual ~MUIFreeLabel2();
  427.         MUIFreeLabel2 &operator= (const MUIFreeLabel2 &);
  428.     };
  429.  
  430. class MUIFreeLLabel : public MUIText
  431.     {
  432.     public:
  433.         MUIFreeLLabel(const STRPTR lab)
  434.             :   MUIText(
  435.                     MUIA_Text_Contents, lab,
  436.                     MUIA_Weight, 0,
  437.                     MUIA_InnerLeft, 0,
  438.                     MUIA_InnerRight, 0,
  439.                     MUIA_FramePhantomHoriz, TRUE,
  440.                     MUIA_Text_SetVMax, FALSE,
  441.                     TAG_DONE)
  442.             { };
  443.         MUIFreeLLabel(const MUIFreeLLabel &p) : MUIText((MUIText &)p) { };
  444.         virtual ~MUIFreeLLabel();
  445.         MUIFreeLLabel &operator= (const MUIFreeLLabel &);
  446.     };
  447.  
  448. class MUIFreeLLabel1 : public MUIText
  449.     {
  450.     public:
  451.         MUIFreeLLabel1(const STRPTR lab)
  452.             :   MUIText(
  453.                     MUIA_Text_Contents, lab,
  454.                     MUIA_Weight, 0,
  455.                     MUIA_InnerLeft, 0,
  456.                     MUIA_InnerRight, 0,
  457.                     MUIA_FramePhantomHoriz, TRUE,
  458.                     MUIA_Text_SetVMax, FALSE,
  459.                     MUIA_Frame, MUIV_Frame_Button,
  460.                     TAG_DONE)
  461.             { };
  462.         MUIFreeLLabel1(const MUIFreeLLabel1 &p) : MUIText((MUIText &)p) { };
  463.         virtual ~MUIFreeLLabel1();
  464.         MUIFreeLLabel1 &operator= (const MUIFreeLLabel1 &);
  465.     };
  466.  
  467. class MUIFreeLLabel2 : public MUIText
  468.     {
  469.     public:
  470.         MUIFreeLLabel2(const STRPTR lab)
  471.             :   MUIText(
  472.                     MUIA_Text_Contents, lab,
  473.                     MUIA_Weight, 0,
  474.                     MUIA_InnerLeft, 0,
  475.                     MUIA_InnerRight, 0,
  476.                     MUIA_FramePhantomHoriz, TRUE,
  477.                     MUIA_Text_SetVMax, FALSE,
  478.                     MUIA_Frame, MUIV_Frame_String,
  479.                     TAG_DONE)
  480.             { };
  481.         MUIFreeLLabel2(const MUIFreeLLabel2 &p) : MUIText((MUIText &)p) { };
  482.         virtual ~MUIFreeLLabel2();
  483.         MUIFreeLLabel2 &operator= (const MUIFreeLLabel2 &);
  484.     };
  485.  
  486. class MUIFreeCLabel : public MUIText
  487.     {
  488.     public:
  489.         MUIFreeCLabel(const STRPTR lab)
  490.             :   MUIText(
  491.                     MUIA_Text_Contents, lab,
  492.                     MUIA_Weight, 0,
  493.                     MUIA_InnerLeft, 0,
  494.                     MUIA_InnerRight, 0,
  495.                     MUIA_FramePhantomHoriz, TRUE,
  496.                     MUIA_Text_SetVMax, FALSE,
  497.                     MUIA_Text_PreParse, MUIX_C,
  498.                     TAG_DONE)
  499.             { };
  500.         MUIFreeCLabel(const MUIFreeCLabel &p) : MUIText((MUIText &)p) { };
  501.         virtual ~MUIFreeCLabel();
  502.         MUIFreeCLabel &operator= (const MUIFreeCLabel &);
  503.     };
  504.  
  505. class MUIFreeCLabel1 : public MUIText
  506.     {
  507.     public:
  508.         MUIFreeCLabel1(const STRPTR lab)
  509.             :   MUIText(
  510.                     MUIA_Text_Contents, lab,
  511.                     MUIA_Weight, 0,
  512.                     MUIA_InnerLeft, 0,
  513.                     MUIA_InnerRight, 0,
  514.                     MUIA_FramePhantomHoriz, TRUE,
  515.                     MUIA_Text_SetVMax, FALSE,
  516.                     MUIA_Text_PreParse, MUIX_C,
  517.                     MUIA_Frame, MUIV_Frame_Button,
  518.                     TAG_DONE)
  519.             { };
  520.         MUIFreeCLabel1(const MUIFreeCLabel1 &p) : MUIText((MUIText &)p) { };
  521.         virtual ~MUIFreeCLabel1();
  522.         MUIFreeCLabel1 &operator= (const MUIFreeCLabel1 &);
  523.     };
  524.  
  525. class MUIFreeCLabel2 : public MUIText
  526.     {
  527.     public:
  528.         MUIFreeCLabel2(const STRPTR lab)
  529.             :   MUIText(
  530.                     MUIA_Text_Contents, lab,
  531.                     MUIA_Weight, 0,
  532.                     MUIA_InnerLeft, 0,
  533.                     MUIA_InnerRight, 0,
  534.                     MUIA_FramePhantomHoriz, TRUE,
  535.                     MUIA_Text_SetVMax, FALSE,
  536.                     MUIA_Text_PreParse, MUIX_C,
  537.                     MUIA_Frame, MUIV_Frame_String,
  538.                     TAG_DONE)
  539.             { };
  540.         MUIFreeCLabel2(const MUIFreeCLabel2 &p) : MUIText((MUIText &)p) { };
  541.         virtual ~MUIFreeCLabel2();
  542.         MUIFreeCLabel2 &operator= (const MUIFreeCLabel2 &);
  543.     };
  544.  
  545. class MUIFreeKeyLabel : public MUIText
  546.     {
  547.     public:
  548.         MUIFreeKeyLabel(const STRPTR lab, const UBYTE hichar)
  549.             :   MUIText(
  550.                     MUIA_Text_Contents, lab,
  551.                     MUIA_Weight, 0,
  552.                     MUIA_InnerLeft, 0,
  553.                     MUIA_InnerRight, 0,
  554.                     MUIA_FramePhantomHoriz, TRUE,
  555.                     MUIA_Text_SetVMax, FALSE,
  556.                     MUIA_Text_HiChar, hichar,
  557.                     MUIA_Text_PreParse, MUIX_R,
  558.                     TAG_DONE)
  559.             { };
  560.         MUIFreeKeyLabel(const MUIFreeKeyLabel &p) : MUIText((MUIText &)p) { };
  561.         virtual ~MUIFreeKeyLabel();
  562.         MUIFreeKeyLabel &operator= (const MUIFreeKeyLabel &);
  563.     };
  564.  
  565. class MUIFreeKeyLabel1 : public MUIText
  566.     {
  567.     public:
  568.         MUIFreeKeyLabel1(const STRPTR lab, const UBYTE hichar)
  569.             :   MUIText(
  570.                     MUIA_Text_Contents, lab,
  571.                     MUIA_Weight, 0,
  572.                     MUIA_InnerLeft, 0,
  573.                     MUIA_InnerRight, 0,
  574.                     MUIA_FramePhantomHoriz, TRUE,
  575.                     MUIA_Text_SetVMax, FALSE,
  576.                     MUIA_Text_HiChar, hichar,
  577.                     MUIA_Frame, MUIV_Frame_Button,
  578.                     MUIA_Text_PreParse, MUIX_R,
  579.                     TAG_DONE)
  580.             { };
  581.         MUIFreeKeyLabel1(const MUIFreeKeyLabel1 &p) : MUIText((MUIText &)p) { };
  582.         virtual ~MUIFreeKeyLabel1();
  583.         MUIFreeKeyLabel1 &operator= (const MUIFreeKeyLabel1 &);
  584.     };
  585.  
  586. class MUIFreeKeyLabel2 : public MUIText
  587.     {
  588.     public:
  589.         MUIFreeKeyLabel2(const STRPTR lab, const UBYTE hichar)
  590.             :   MUIText(
  591.                     MUIA_Text_Contents, lab,
  592.                     MUIA_Weight, 0,
  593.                     MUIA_InnerLeft, 0,
  594.                     MUIA_InnerRight, 0,
  595.                     MUIA_FramePhantomHoriz, TRUE,
  596.                     MUIA_Text_SetVMax, FALSE,
  597.                     MUIA_Text_HiChar, hichar,
  598.                     MUIA_Frame, MUIV_Frame_String,
  599.                     MUIA_Text_PreParse, MUIX_R,
  600.                     TAG_DONE)
  601.             { };
  602.         MUIFreeKeyLabel2(const MUIFreeKeyLabel2 &p) : MUIText((MUIText &)p) { };
  603.         virtual ~MUIFreeKeyLabel2();
  604.         MUIFreeKeyLabel2 &operator= (const MUIFreeKeyLabel2 &);
  605.     };
  606.  
  607. class MUIFreeKeyLLabel : public MUIText
  608.     {
  609.     public:
  610.         MUIFreeKeyLLabel(const STRPTR lab, const UBYTE hichar)
  611.             :   MUIText(
  612.                     MUIA_Text_Contents, lab,
  613.                     MUIA_Weight, 0,
  614.                     MUIA_InnerLeft, 0,
  615.                     MUIA_InnerRight, 0,
  616.                     MUIA_FramePhantomHoriz, TRUE,
  617.                     MUIA_Text_SetVMax, FALSE,
  618.                     MUIA_Text_HiChar, hichar,
  619.                     TAG_DONE)
  620.             { };
  621.         MUIFreeKeyLLabel(const MUIFreeKeyLLabel &p) : MUIText((MUIText &)p) { };
  622.         virtual ~MUIFreeKeyLLabel();
  623.         MUIFreeKeyLLabel &operator= (const MUIFreeKeyLLabel &);
  624.     };
  625.  
  626. class MUIFreeKeyLLabel1 : public MUIText
  627.     {
  628.     public:
  629.         MUIFreeKeyLLabel1(const STRPTR lab, const UBYTE hichar)
  630.             :   MUIText(
  631.                     MUIA_Text_Contents, lab,
  632.                     MUIA_Weight, 0,
  633.                     MUIA_InnerLeft, 0,
  634.                     MUIA_InnerRight, 0,
  635.                     MUIA_FramePhantomHoriz, TRUE,
  636.                     MUIA_Text_SetVMax, FALSE,
  637.                     MUIA_Text_HiChar, hichar,
  638.                     MUIA_Frame, MUIV_Frame_Button,
  639.                     TAG_DONE)
  640.             { };
  641.         MUIFreeKeyLLabel1(const MUIFreeKeyLLabel1 &p) : MUIText((MUIText &)p) { };
  642.         virtual ~MUIFreeKeyLLabel1();
  643.         MUIFreeKeyLLabel1 &operator= (const MUIFreeKeyLLabel1 &);
  644.     };
  645.  
  646. class MUIFreeKeyLLabel2 : public MUIText
  647.     {
  648.     public:
  649.         MUIFreeKeyLLabel2(const STRPTR lab, const UBYTE hichar)
  650.             :   MUIText(
  651.                     MUIA_Text_Contents, lab,
  652.                     MUIA_Weight, 0,
  653.                     MUIA_InnerLeft, 0,
  654.                     MUIA_InnerRight, 0,
  655.                     MUIA_FramePhantomHoriz, TRUE,
  656.                     MUIA_Text_SetVMax, FALSE,
  657.                     MUIA_Text_HiChar, hichar,
  658.                     MUIA_Frame, MUIV_Frame_String,
  659.                     TAG_DONE)
  660.             { };
  661.         MUIFreeKeyLLabel2(const MUIFreeKeyLLabel2 &p) : MUIText((MUIText &)p) { };
  662.         virtual ~MUIFreeKeyLLabel2();
  663.         MUIFreeKeyLLabel2 &operator= (const MUIFreeKeyLLabel2 &);
  664.     };
  665.  
  666. class MUIFreeKeyCLabel : public MUIText
  667.     {
  668.     public:
  669.         MUIFreeKeyCLabel(const STRPTR lab, const UBYTE hichar)
  670.             :   MUIText(
  671.                     MUIA_Text_Contents, lab,
  672.                     MUIA_Weight, 0,
  673.                     MUIA_InnerLeft, 0,
  674.                     MUIA_InnerRight, 0,
  675.                     MUIA_FramePhantomHoriz, TRUE,
  676.                     MUIA_Text_SetVMax, FALSE,
  677.                     MUIA_Text_HiChar, hichar,
  678.                     MUIA_Text_PreParse, MUIX_C,
  679.                     TAG_DONE)
  680.             { };
  681.         MUIFreeKeyCLabel(const MUIFreeKeyCLabel &p) : MUIText((MUIText &)p) { };
  682.         virtual ~MUIFreeKeyCLabel();
  683.         MUIFreeKeyCLabel &operator= (const MUIFreeKeyCLabel &);
  684.     };
  685.  
  686. class MUIFreeKeyCLabel1 : public MUIText
  687.     {
  688.     public:
  689.         MUIFreeKeyCLabel1(const STRPTR lab, const UBYTE hichar)
  690.             :   MUIText(
  691.                     MUIA_Text_Contents, lab,
  692.                     MUIA_Weight, 0,
  693.                     MUIA_InnerLeft, 0,
  694.                     MUIA_InnerRight, 0,
  695.                     MUIA_FramePhantomHoriz, TRUE,
  696.                     MUIA_Text_SetVMax, FALSE,
  697.                     MUIA_Text_HiChar, hichar,
  698.                     MUIA_Text_PreParse, MUIX_C,
  699.                     MUIA_Frame, MUIV_Frame_Button,
  700.                     TAG_DONE)
  701.             { };
  702.         MUIFreeKeyCLabel1(const MUIFreeKeyCLabel1 &p) : MUIText((MUIText &)p) { };
  703.         virtual ~MUIFreeKeyCLabel1();
  704.         MUIFreeKeyCLabel1 &operator= (const MUIFreeKeyCLabel1 &);
  705.     };
  706.  
  707. class MUIFreeKeyCLabel2 : public MUIText
  708.     {
  709.     public:
  710.         MUIFreeKeyCLabel2(const STRPTR lab, const UBYTE hichar)
  711.             :   MUIText(
  712.                     MUIA_Text_Contents, lab,
  713.                     MUIA_Weight, 0,
  714.                     MUIA_InnerLeft, 0,
  715.                     MUIA_InnerRight, 0,
  716.                     MUIA_FramePhantomHoriz, TRUE,
  717.                     MUIA_Text_SetVMax, FALSE,
  718.                     MUIA_Text_HiChar, hichar,
  719.                     MUIA_Text_PreParse, MUIX_C,
  720.                     MUIA_Frame, MUIV_Frame_String,
  721.                     TAG_DONE)
  722.             { };
  723.         MUIFreeKeyCLabel2(const MUIFreeKeyCLabel2 &p) : MUIText((MUIText &)p) { };
  724.         virtual ~MUIFreeKeyCLabel2();
  725.         MUIFreeKeyCLabel2 &operator= (const MUIFreeKeyCLabel2 &);
  726.     };
  727.  
  728. #endif
  729.